package com.example.mybatisplusdemo.service;

import com.example.mybatisplusdemo.model.domain.User;
import com.example.mybatisplusdemo.model.dto.UserCenterDTO;
import com.example.mybatisplusdemo.service.impl.UserServiceImpl;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;

/**
 * <p>
 * 用户中心服务类
 * </p>
 *
 * @author yangpengfei
 * @since 2025/01/27
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class UserCenterService {

    private final IUserService userService;

    private final ObjectMapper objectMapper;

    // 会员等级映射
    private static final Map<String, String> MEMBER_LEVEL_MAP = new HashMap<>();
    // 推荐类别标签类型映射
    private static final Map<String, String> CATEGORY_TAG_MAP = new HashMap<>();
    
    static {
        MEMBER_LEVEL_MAP.put("BRONZE", "铜卡会员");
        MEMBER_LEVEL_MAP.put("SILVER", "银卡会员");
        MEMBER_LEVEL_MAP.put("GOLD", "金卡会员");
        MEMBER_LEVEL_MAP.put("PLATINUM", "白金会员");
        MEMBER_LEVEL_MAP.put("DIAMOND", "钻石会员");
        
        CATEGORY_TAG_MAP.put("航班推荐", "success");
        CATEGORY_TAG_MAP.put("目的地推荐", "primary");
        CATEGORY_TAG_MAP.put("会员专享", "warning");
        CATEGORY_TAG_MAP.put("增值服务", "info");
    }

    /**
     * 获取用户中心数据
     * 
     * 业务逻辑说明：
     * 1. 获取用户基本信息
     * 2. 分析用户偏好和消费习惯
     * 3. 生成个性化推荐
     * 4. 组装返回数据
     * 
     * @param userId 用户ID
     * @return UserCenterDTO 用户中心数据
     */
    public UserCenterDTO getUserCenterData(Long userId) {
        User user = userService.getById(userId);
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }

        UserCenterDTO userCenterDTO = new UserCenterDTO();
        
        // 构建用户信息
        UserCenterDTO.UserInfo userInfo = buildUserInfo(user);
        userCenterDTO.setUser(userInfo);
        
        // 生成个性化推荐
        List<UserCenterDTO.Recommendation> recommendations = generateRecommendationList(user);
        userCenterDTO.setRecommendations(recommendations);
        
        return userCenterDTO;
    }

    /**
     * 构建用户信息
     * 
     * @param user 用户实体
     * @return UserInfo 用户信息
     */
    private UserCenterDTO.UserInfo buildUserInfo(User user) {
        UserCenterDTO.UserInfo userInfo = new UserCenterDTO.UserInfo();
        
        userInfo.setId("U" + user.getId());
        userInfo.setName(user.getUsername());
        userInfo.setAvatarUrl(""); // 暂时为空，可以后续扩展
        userInfo.setLevel(determineMemberLevel(user));
        userInfo.setPoints(calculateUserPoints(user));
        userInfo.setTravelPrefs(analyzeTravelPreferences(user));
        userInfo.setSpendingAnalysis(analyzeSpendingHabits(user));
        userInfo.setContact(maskPhoneNumber(user.getPhone()));
        userInfo.setEmail(user.getEmail());
        
        return userInfo;
    }

    /**
     * 确定会员等级
     * 
     * @param user 用户实体
     * @return String 会员等级
     */
    private String determineMemberLevel(User user) {
        // 根据用户年龄和偏好确定会员等级
        Integer age = user.getAge();
        if (age != null && age > 35) {
            return MEMBER_LEVEL_MAP.get("GOLD");
        } else if (age != null && age > 25) {
            return MEMBER_LEVEL_MAP.get("SILVER");
        } else {
            return MEMBER_LEVEL_MAP.get("BRONZE");
        }
    }

    /**
     * 计算用户积分
     * 
     * @param user 用户实体
     * @return Integer 积分
     */
    private Integer calculateUserPoints(User user) {
        // 基础积分 + 年龄加成
        int basePoints = 5000;
        Integer age = user.getAge();
        if (age != null) {
            basePoints += age * 100;
        }
        return basePoints;
    }

    /**
     * 分析出行偏好
     * 
     * @param user 用户实体
     * @return List<String> 偏好标签列表
     */
    private List<String> analyzeTravelPreferences(User user) {
        List<String> prefs = new ArrayList<>();
        
        try {
            // 解析用户偏好设置JSON
            Map<String, Object> preferences = parseJsonString(user.getPreferences());
            
            // 从preferences中获取座位和餐食偏好
            if (preferences != null) {
                String seatPreference = (String) preferences.get("seat_preference");
                String mealPreference = (String) preferences.get("meal_preference");
                
                if ("aisle".equals(seatPreference)) {
                    prefs.add("偏好过道座位");
                } else if ("window".equals(seatPreference)) {
                    prefs.add("偏好靠窗座位");
                } else if ("exit_row".equals(seatPreference)) {
                    prefs.add("偏好紧急出口座位");
                }
                
                if ("素食".equals(mealPreference)) {
                    prefs.add("偏好素食");
                } else if ("低盐".equals(mealPreference)) {
                    prefs.add("偏好低盐饮食");
                } else if ("清真".equals(mealPreference)) {
                    prefs.add("偏好清真饮食");
                }
            }
            
            // 根据用户基本信息分析
            String preferredPriceRange = user.getPreferredPriceRange();
            String preferredDepartureTime = user.getPreferredDepartureTime();
            String preferredAirline = user.getPreferredAirline();
            String gender = user.getGender();
            Integer age = user.getAge();
            
            // 价格偏好分析
            if (preferredPriceRange != null) {
                if (preferredPriceRange.contains("5000") && preferredPriceRange.contains("以上")) {
                    prefs.add("商务出行");
                    prefs.add("高端舱位偏好");
                } else if (preferredPriceRange.contains("1500-5000")) {
                    prefs.add("品质出行");
                } else {
                    prefs.add("经济实惠");
                }
                prefs.add(preferredPriceRange + "消费水平");
            }
            
            // 时间偏好分析
            if ("早上".equals(preferredDepartureTime)) {
                prefs.add("偏好早上出发");
            } else if ("晚上".equals(preferredDepartureTime)) {
                prefs.add("偏好晚上出发");
            } else if ("下午".equals(preferredDepartureTime)) {
                prefs.add("偏好下午出发");
            }
            
            // 航空公司偏好
            if (preferredAirline != null && !preferredAirline.isEmpty()) {
                prefs.add("偏好" + preferredAirline);
            }
            
            // 年龄和性别相关偏好
            if (age != null) {
                if (age > 35) {
                    prefs.add("中年");
                } else if (age <= 30) {
                    prefs.add("青年");
                }
            }
            
            if ("男".equals(gender)) {
                prefs.add("男性");
            } else if ("女".equals(gender)) {
                prefs.add("女性");
            }
            
            // 分析收藏机场数量
            List<String> favoriteAirports = parseJsonArray(user.getFavoriteAirports());
            if (favoriteAirports != null && !favoriteAirports.isEmpty()) {
                prefs.add(favoriteAirports.size() + "个收藏机场");
            }
            
            // 分析历史航班
            List<String> travelHistory = parseJsonArray(user.getTravelHistory());
            if (travelHistory != null && !travelHistory.isEmpty()) {
                prefs.add(travelHistory.size() + "次历史航班");
                
                // 分析常去目的地
                Map<String, Integer> cityCount = new HashMap<>();
                for (String route : travelHistory) {
                    String[] cities = route.split("-");
                    if (cities.length >= 2) {
                        String departure = cities[0];
                        cityCount.put(departure, cityCount.getOrDefault(departure, 0) + 1);
                    }
                }
                
                // 找出最常去的城市
                String mostVisitedCity = cityCount.entrySet().stream()
                    .max(Map.Entry.comparingByValue())
                    .map(Map.Entry::getKey)
                    .orElse(null);
                    
                if (mostVisitedCity != null) {
                    prefs.add(mostVisitedCity + "为常去目的地");
                }
                
                // 分析热门航线
                if (!travelHistory.isEmpty()) {
                    prefs.add(travelHistory.get(0) + "热门航线");
                }
                
                // 计算独特目的地数量
                Set<String> uniqueDestinations = new HashSet<>();
                for (String route : travelHistory) {
                    String[] cities = route.split("-");
                    for (String city : cities) {
                        uniqueDestinations.add(city);
                    }
                }
                prefs.add(uniqueDestinations.size() + "个独特目的地");
            }
            
        } catch (Exception e) {
            log.warn("解析用户偏好数据失败: {}", e.getMessage());
            // 默认偏好
            prefs.add("国内航班");
            prefs.add("直飞优先");
        }
        
        return prefs;
    }

    /**
     * 分析消费习惯
     * 
     * @param user 用户实体
     * @return List<SpendingAnalysis> 消费分析
     */
    private List<UserCenterDTO.SpendingAnalysis> analyzeSpendingHabits(User user) {
        List<UserCenterDTO.SpendingAnalysis> analysis = new ArrayList<>();
        
        String preferredPriceRange = user.getPreferredPriceRange();
        
        if (preferredPriceRange != null) {
            if ("1500-5000元".equals(preferredPriceRange)) {
                analysis.add(createSpendingAnalysis("1500-5000元", 55));
                analysis.add(createSpendingAnalysis("1000-2000元", 30));
                analysis.add(createSpendingAnalysis("5000元以上", 15));
            } else if ("1000-3000元".equals(preferredPriceRange)) {
                analysis.add(createSpendingAnalysis("1000-3000元", 50));
                analysis.add(createSpendingAnalysis("800-2000元", 35));
                analysis.add(createSpendingAnalysis("3000元以上", 15));
            } else if ("800-2000元".equals(preferredPriceRange)) {
                analysis.add(createSpendingAnalysis("800-2000元", 60));
                analysis.add(createSpendingAnalysis("1000-3000元", 25));
                analysis.add(createSpendingAnalysis("2000元以上", 15));
            } else {
                // 默认分析
                analysis.add(createSpendingAnalysis("1000-2000元", 45));
                analysis.add(createSpendingAnalysis("2000-5000元", 40));
                analysis.add(createSpendingAnalysis("5000元以上", 15));
            }
        } else {
            // 默认分析
            analysis.add(createSpendingAnalysis("1000-2000元", 45));
            analysis.add(createSpendingAnalysis("2000-5000元", 40));
            analysis.add(createSpendingAnalysis("5000元以上", 15));
        }
        
        return analysis;
    }

    /**
     * 创建消费分析对象
     * 
     * @param label 标签
     * @param percentage 百分比
     * @return SpendingAnalysis 消费分析
     */
    private UserCenterDTO.SpendingAnalysis createSpendingAnalysis(String label, Integer percentage) {
        UserCenterDTO.SpendingAnalysis analysis = new UserCenterDTO.SpendingAnalysis();
        analysis.setLabel(label);
        analysis.setPercentage(percentage);
        return analysis;
    }

    /**
     * 生成个性化推荐列表
     * 
     * @param user 用户实体
     * @return List<Recommendation> 推荐列表
     */
    public List<UserCenterDTO.Recommendation> generateRecommendationList(User user) {
        List<UserCenterDTO.Recommendation> recommendations = new ArrayList<>();
        
        // 根据用户偏好生成不同类型的推荐
        recommendations.add(generateFlightRecommendation(user));
        recommendations.add(generateDestinationRecommendation(user));
        recommendations.add(generateMemberRecommendation(user));
        recommendations.add(generateServiceRecommendation(user));
        
        return recommendations;
    }

    /**
     * 生成航班推荐
     * 
     * @param user 用户实体
     * @return Recommendation 航班推荐
     */
    private UserCenterDTO.Recommendation generateFlightRecommendation(User user) {
        UserCenterDTO.Recommendation recommendation = new UserCenterDTO.Recommendation();
        recommendation.setId("R" + System.currentTimeMillis() + "001");
        recommendation.setCategory("航班推荐");
        recommendation.setTagType(CATEGORY_TAG_MAP.get("航班推荐"));
        
        String preferredPriceRange = user.getPreferredPriceRange();
        if ("5000元以上".equals(preferredPriceRange)) {
            recommendation.setTitle("北京 → 上海 商务舱特惠");
            recommendation.setDescription("根据您的商务出行习惯，为您推荐的直达航班优惠");
            recommendation.setDiscount("直降45%，原价¥2300 现价¥1250");
            recommendation.setLocation("北京(BJS) ⇌ 上海(SHA)");
        } else {
            recommendation.setTitle("热门航线经济舱优惠");
            recommendation.setDescription("为您精选的性价比航班推荐");
            recommendation.setDiscount("限时8折，最高立减¥500");
            recommendation.setLocation("多条热门航线");
        }
        
        recommendation.setDuration("即日起至2024年12月31日");
        return recommendation;
    }

    /**
     * 生成目的地推荐
     * 
     * @param user 用户实体
     * @return Recommendation 目的地推荐
     */
    private UserCenterDTO.Recommendation generateDestinationRecommendation(User user) {
        UserCenterDTO.Recommendation recommendation = new UserCenterDTO.Recommendation();
        recommendation.setId("R" + System.currentTimeMillis() + "002");
        recommendation.setTitle("三亚海滨度假套餐");
        recommendation.setDescription("根据您的出行偏好，为您精选的海滩风光套餐");
        recommendation.setCategory("目的地推荐");
        recommendation.setDiscount("7天5晚，立省¥1320");
        recommendation.setLocation("三亚");
        recommendation.setDuration("即日起至2024年3月31日");
        recommendation.setTagType(CATEGORY_TAG_MAP.get("目的地推荐"));
        return recommendation;
    }

    /**
     * 生成会员推荐
     * 
     * @param user 用户实体
     * @return Recommendation 会员推荐
     */
    private UserCenterDTO.Recommendation generateMemberRecommendation(User user) {
        UserCenterDTO.Recommendation recommendation = new UserCenterDTO.Recommendation();
        recommendation.setId("R" + System.currentTimeMillis() + "003");
        recommendation.setTitle("国际航线会员专享");
        recommendation.setDescription("会员专享国际航线特别优惠");
        recommendation.setCategory("会员专享");
        recommendation.setDiscount("东京/首尔/曼谷7折起");
        recommendation.setLocation("亚洲热门目的地");
        recommendation.setDuration("2024年12月15日前预订");
        recommendation.setTagType(CATEGORY_TAG_MAP.get("会员专享"));
        return recommendation;
    }

    /**
     * 生成服务推荐
     * 
     * @param user 用户实体
     * @return Recommendation 服务推荐
     */
    private UserCenterDTO.Recommendation generateServiceRecommendation(User user) {
        UserCenterDTO.Recommendation recommendation = new UserCenterDTO.Recommendation();
        recommendation.setId("R" + System.currentTimeMillis() + "004");
        recommendation.setTitle("机场贵宾厅年卡特惠");
        recommendation.setDescription("根据您的出行频次，推荐最优权益");
        recommendation.setCategory("增值服务");
        recommendation.setDiscount("高级会员年卡立减¥500");
        recommendation.setLocation("全国主要机场");
        recommendation.setDuration("即日起至2024年12月10日");
        recommendation.setTagType(CATEGORY_TAG_MAP.get("增值服务"));
        return recommendation;
    }

    /**
     * 提交用户反馈
     * 
     * 业务逻辑说明：
     * 1. 验证反馈内容
     * 2. 记录反馈信息到日志
     * 3. 可以扩展为保存到数据库
     * 
     * @param userId 用户ID
     * @param type 反馈类型
     * @param content 反馈内容
     * @param contact 联系方式
     */
    public void submitFeedback(Long userId, String type, String content, String contact) {
        // 记录反馈信息
        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        log.info("用户反馈 - 时间: {}, 用户ID: {}, 类型: {}, 内容: {}, 联系方式: {}", 
                timestamp, userId, type, content, contact);
        
        // 这里可以扩展为保存到数据库的逻辑
        // 例如：feedbackMapper.insert(feedback);
    }

    /**
     * 生成推荐内容（用于刷新）
     * 
     * @param userId 用户ID
     * @return Object 推荐内容
     */
    public Object generateRecommendations(Long userId) {
        User user = userService.getById(userId);
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }
        
        return generateRecommendationList(user);
    }

    /**
     * 手机号脱敏处理
     * 
     * @param phone 手机号
     * @return String 脱敏后的手机号
     */
    private String maskPhoneNumber(String phone) {
        if (phone == null || phone.length() < 7) {
            return phone;
        }
        return phone.substring(0, 3) + "****" + phone.substring(phone.length() - 4);
    }
    
    /**
     * 解析JSON字符串为Map
     * 
     * @param jsonString JSON字符串
     * @return Map<String, Object> 解析后的Map
     */
    private Map<String, Object> parseJsonString(String jsonString) {
        if (jsonString == null || jsonString.trim().isEmpty()) {
            return new HashMap<>();
        }
        
        try {
            return objectMapper.readValue(jsonString, new TypeReference<Map<String, Object>>() {});
        } catch (Exception e) {
            log.warn("解析JSON字符串失败: {}", e.getMessage());
            return new HashMap<>();
        }
    }
    
    /**
     * 解析JSON数组字符串为List
     * 
     * @param jsonArrayString JSON数组字符串
     * @return List<String> 解析后的List
     */
    private List<String> parseJsonArray(String jsonArrayString) {
        if (jsonArrayString == null || jsonArrayString.trim().isEmpty()) {
            return new ArrayList<>();
        }
        
        try {
            return objectMapper.readValue(jsonArrayString, new TypeReference<List<String>>() {});
        } catch (Exception e) {
            log.warn("解析JSON数组字符串失败: {}", e.getMessage());
            return new ArrayList<>();
        }
    }
}